Language Interoperability Safe C++

Most software systems are created not with a single language but instead with a collection of languages each carefully chosen to solve a particular set of problems within those systems. Typically the facilities for these languages to interoperate are constructed in an ah-hoc fashion and are thus tedious to use, error-prone, and do not preserve the safety properties of the languages involved. I am interested in constructing foundationsbased interoperability boundaries that do not have these problems and thus make language interoperability a viable alternative when building large systems. Previous research into language interoperability developed common runtimes that could support multiple languages, culminating in the development of the .NET framework and the evolution of the Java virtual machine to support multiple languages. However, comparatively less attention has been paid to understanding the semantics of interoperability. This is less important when we consider similar language pairs such as C++ and Java, but it is critical when the languages involved have safety properties that must be preserved even in the presence of interoperability, e.g., a dependently-typed or linearly-typed language. I argue [2] that this distinction is important not just for end-users (i.e., programmers) but also language developers and researchers creating advanced programming languages. When developing a fancy new type system and language, designers must jump through many theoretical and implementation hoops or compromise on their core design in a significant way in order to integrate their ideas into a conventional language. However, I suggest that an alternative, potentially more fruitful approach is to stick with a simple core language but instead put effort into building semantics-preserving interoperability boundaries into other languages. With Vilhelm Sjöberg, I’ve begun to explore semantics-preserving interoperability for dependentlytyped languages [1]. We developed a core calculus modeling interop boundaries between simply-typed and dependently-typed lambda calculi with datatypes. Our goal was to identify what dynamic checks were necessary to preserve the guarantees made by dependently-typed code even while executing simply-typed code. We found several subtleties during this process, for example, the need for special constructs to bind values from one language into the other. We also proved standard progress and preservation for our system, demonstrating that we indeed created safe interop boundaries between the two calculi.